package com.blogsystem.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.blogsystem.common.PageResult;
import com.blogsystem.common.Result;
import com.blogsystem.entity.Article;
import com.blogsystem.entity.Category;
import com.blogsystem.entity.Comment;
import com.blogsystem.entity.User;
import com.blogsystem.service.ArticleService;
import com.blogsystem.service.CategoryService;
import com.blogsystem.service.CommentService;
import com.blogsystem.service.UserService;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.csrf.CsrfToken;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.thymeleaf.context.Context;
import org.thymeleaf.TemplateEngine;


/**
 * 管理员控制器，处理后台管理相关的请求。
 * 包括用户管理、文章审核、分类管理、评论管理和数据统计等功能。
 */
@Controller
@RequestMapping("/api/admin")
public class AdminController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    @Autowired
    private UserService userService;

    @Autowired
    private ArticleService articleService;

    @Autowired
    private CommentService commentService;

    @Autowired
    private CategoryService categoryService;

    @Autowired
    private TemplateEngine templateEngine; // 注入TemplateEngine用于动态加载Thymeleaf模板

    /**
     * 显示管理员仪表盘页面
     *
     * @param model 模型对象，用于传递数据到视图
     * @return 返回视图名称 "admin/dashboard"
     */
    @GetMapping("/dashboard")
    public String adminDashboard(Model model) {
        model.addAttribute("stat", getAdminStatistics());
        return "admin/dashboard";
    }
    /**
     * 分页获取用户列表，支持按用户名搜索
     *
     * @param keyword 搜索关键词，可选
     * @param page    当前页码，默认为1
     * @param limit   每页显示的记录数，默认为10
     * @return 返回用户列表的 JSON 数据
     */

    @GetMapping("/user/list")
    @ResponseBody
    public Map<String, Object> listUsers(
            @RequestParam(required = false) String keyword,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer limit
    ) {
        logger.info("开始获取用户列表，页码：" + page + ", 每页记录数：" + limit);
        Map<String, Object> result = new HashMap<>();
        Page<User> userPage;
        if (keyword != null &&!keyword.isEmpty()) {
            userPage = userService.searchUsersByUsername(keyword, page, limit);
            logger.info("搜索用户：" + keyword);
        } else {
            userPage = userService.list(page, limit);
            logger.info("获取用户列表");
        }
        result.put("code", 0);
        result.put("msg", "用户列表获取成功");
        result.put("data", userPage.getRecords());
        result.put("count", userPage.getTotal());
        return result;
    }
    @PostMapping("/user/batch")
    @ResponseBody
    public Map<String, Object> batchOperateUsers(@RequestParam String action,
                                                 @RequestParam List<Integer> ids) {
        Map<String, Object> result = new HashMap<>();
        try {
            if ("delete".equals(action)) {
                userService.removeByIds(ids);
            } else if ("enable".equals(action)) {
                for (Integer id : ids) {
                    User user = userService.getById(id);
                    user.setRole(0); // 启用
                    userService.updateById(user);
                }
            } else if ("disable".equals(action)) {
                for (Integer id : ids) {
                    User user = userService.getById(id);
                    user.setRole(-1); // 禁用
                    userService.updateById(user);
                }
            }

            result.put("code", 0);
            result.put("msg", "操作成功");
        } catch (Exception e) {
            result.put("code", 1);
            result.put("msg", "操作失败：" + e.getMessage());
        }
        return result;
    }
    @PostMapping("/user/update-role/{id}")
    public String updateUserRole(@PathVariable Integer id, @RequestParam Integer role) {
        User user = new User();
        user.setUserId(id);
        user.setRole(role);
        userService.updateById(user);
        return "redirect:/admin/user/list";
    }

    /**
     * 禁用指定ID的用户
     *
     * @param id 用户ID
     * @return 重定向到用户列表页面
     */
    @PostMapping("/user/disable/{id}")
    public String disableUser(@PathVariable Integer id) {
        // 假设你有 is_disabled 字段，或设置 role 为 -1 表示禁用
        User user = userService.getById(id);
        user.setRole(-1); // 或添加 is_disabled 字段
        userService.updateById(user);
        return "redirect:/admin/user/list";
    }
    @DeleteMapping("/user/{id}")
    public Result deleteUser1(@PathVariable Integer id) {
        logger.info("删除用户：" + id);
        System.out.println("删除用户：" + id);
        try {
            User user = userService.getById(id);
            if (user == null) {
                return new Result(1, "用户不存在，无法删除");
            }
            List<Comment> comments = commentService.getAllCommentsByUserId(id);
            if (!comments.isEmpty()) {
                commentService.removeByIds(comments.stream().map(Comment::getCommentId).toList());
            }
            List<Article> articles = articleService.getAllArticlesByUserId(id);
            if (!articles.isEmpty()) {
                articleService.removeByIds(articles.stream().map(Article::getArticleId).toList());
            }
            userService.removeById(id);
            return new Result(0, "用户及其关联内容删除成功");
        } catch (Exception e) {
            logger.error("删除用户时发生异常：", e);
            return new Result(1, "用户删除失败：" + e.getMessage());
        }
    }
    /**
     * 更新指定ID的用户信息
     *
     * @param id   用户ID
     * @param user 用户对象，包含更新后的信息
     * @return 返回操作结果的 JSON 数据
     */
    @PutMapping("/user/{id}")
    public Map<String, Object> updateUser(@PathVariable Integer id, @RequestBody User user) {
        Map<String, Object> result = new HashMap<>();
        try {
            user.setUserId(id); // 确保更新的是指定用户
            userService.updateById(user);
            result.put("code", 0);
            result.put("msg", "用户更新成功");
        } catch (Exception e) {
            result.put("code", 1);
            result.put("msg", "用户更新失败：" + e.getMessage());
        }
        return result;
    }


    /**
     * 获取所有博客分类列表
     *
     * @return 返回分类列表的 JSON 数据
     */
    @GetMapping("/category/list")
    @ResponseBody
    public Map<String, Object> listCategories(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String categoryName // 增加分类名称搜索参数
    ) {
        Page<Category> page = new Page<>(pageNum, pageSize);
        QueryWrapper<Category> queryWrapper = new QueryWrapper<>();
        if (categoryName != null &&!categoryName.isEmpty()) {
            queryWrapper.like("name", categoryName); // 假设数据库字段是category_name
        }
        Page<Category> categoryPage = categoryService.pageCategories(page, queryWrapper);
        Map<String, Object> result = new HashMap<>();
        result.put("code", 0);
        result.put("msg", "");
        result.put("count", (int) categoryPage.getTotal());
        result.put("data", categoryPage.getRecords());
        return result;
    }


    /**
     * 添加新的博客分类
     *
     * @param name     分类名称
     * @param priority 分类优先级
     * @return 重定向到分类列表页面
     */
    @PostMapping("/category/add")
    public String addCategory(@RequestParam String name, @RequestParam Integer priority) {
        Category category = new Category();
        category.setName(name);
        category.setPriority(priority);
        category.setCreateTime(LocalDateTime.now());
        categoryService.save(category);
        return "redirect:/admin/category/list";
    }

    /**
     * 更新多个分类信息（名称和优先级）
     *
     * @param categoryIds 分类ID列表
     * @param names       分类名称列表
     * @param priorities  分类优先级列表
     * @return 重定向到分类列表页面
     */
    @PostMapping("/category/update")
    public String updateCategories(@RequestParam List<Integer> categoryIds,
                                 @RequestParam List<String> names,
                                 @RequestParam List<Integer> priorities) {
        for (int i = 0; i < categoryIds.size(); i++) {
            Category category = new Category();
            category.setCategoryId(categoryIds.get(i));
            category.setName(names.get(i));
            category.setPriority(priorities.get(i));
            categoryService.updateById(category);
        }
        return "redirect:/admin/category/list";
    }

    /**
     * 删除指定ID的分类
     *
     * @param id 分类ID
     * @return 重定向到分类列表页面
     */
    @PostMapping("/category/delete/{id}")
    public String deleteCategory(@PathVariable Integer id) {
        categoryService.removeById(id);
        return "redirect:/admin/category/list";
    }

    /**
     * 对分类进行批量操作，目前仅支持删除
     *
     * @param action 操作类型："delete"
     * @param ids    要操作的分类ID列表
     * @return 重定向到分类列表页面
     */
    @PostMapping("/category/batch")
@ResponseBody
public Map<String, Object> batchOperateCategories(@RequestParam String action,
                                               @RequestParam List<Integer> ids) {
    Map<String, Object> result = new HashMap<>();
    try {
        if ("delete".equals(action)) {
            categoryService.removeByIds(ids);
        }

        result.put("code", 0);
        result.put("msg", "操作成功");
    } catch (Exception e) {
        result.put("code", 1);
        result.put("msg", "操作失败：" + e.getMessage());
    }
    return result;
}




//    @GetMapping("/article/list")
//    @ResponseBody
//    public PageResult<Article> listArticles(
//            @RequestParam(defaultValue = "1") Integer page,
//            @RequestParam(defaultValue = "10") Integer limit,
//            @RequestParam(required = false) String status,
//            @RequestParam(required = false) String keyword) {
//
//        // 构建查询条件
//        QueryWrapper<Article> queryWrapper = new QueryWrapper<>();
//
//        // 状态筛选
//        if (StringUtils.isNotBlank(status)) {
//            switch (status) {
//                case "pending":
//                    queryWrapper.eq("status", 2); // 待审核
//                    break;
//                case "approved":
//                    queryWrapper.eq("status", 1); // 已通过
//                    break;
//                case "rejected":
//                    queryWrapper.eq("status", 3); // 已驳回
//                    break;
//                // 默认不添加条件，查询所有状态
//            }
//        }
//
//        // 关键词搜索
//        if (StringUtils.isNotBlank(keyword)) {
//            queryWrapper.like("title", keyword);
//        }
//
//        // 分页查询
//        Page<Article> pageResult = articleService.page(new Page<>(page, limit), queryWrapper);
//
//        return new PageResult<>(
//                pageResult.getTotal(),
//                pageResult.getRecords()
//        );
//    }

    @GetMapping("/article/list")
    @ResponseBody
    public List<Article> listArticles(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer limit,
            @RequestParam(required = false) String status,
            @RequestParam(required = false) String keyword) {

        // 构建查询条件
        QueryWrapper<Article> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("status", 0);
        // 状态筛选
        if (StringUtils.isNotBlank(status)) {
            switch (status) {
                case "pending":
                    queryWrapper.eq("status", 2); // 待审核
                    break;
                case "approved":
                    queryWrapper.eq("status", 1); // 已通过
                    break;
                case "rejected":
                    queryWrapper.eq("status", 3); // 已驳回
                    break;
                // 默认不添加条件，查询所有状态
            }
        }

        // 关键词搜索
        if (StringUtils.isNotBlank(keyword)) {
            queryWrapper.like("title", keyword);
        }

        // 分页查询
        Page<Article> pageResult = articleService.page(new Page<>(page, limit), queryWrapper);

        // 直接返回当前页的记录列表
        return pageResult.getRecords();
    }
    @GetMapping("/article/audit")
    @ResponseBody
    public List<Article> listPendingArticles() {
        return articleService.list(new QueryWrapper<Article>().eq("status", 2)); // status=2 表示待审核
    }

    /**
     * 审核通过某篇文章，将其状态设置为已发布
     * @param id 文章ID
     * @return 操作结果
     */
    @PostMapping("/article/approve/{id}")
    @ResponseBody
    public Map<String, Object> approveArticle(@PathVariable Integer id ,HttpServletRequest request) {
        System.out.println("approveArticle called with id: " + id);
        logger.info("approveArticle called with id: " + id);
        // 打印请求中的 CSRF 令牌（从请求头或表单获取）
        String requestToken = request.getHeader("X-CSRF-TOKEN");
        if (requestToken == null) {
            requestToken = request.getParameter("_csrf"); // 表单字段
        }
        logger.info("Request CSRF Token: {}", requestToken);

        // 打印 Session 中的 CSRF 令牌
        CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName());
        if (csrfToken != null) {
            logger.info("Session CSRF Token: {}", csrfToken.getToken());
        }

        Map<String, Object> result = new HashMap<>();
        try {
            Article article = articleService.getById(id);
            if (article == null) {
                result.put("code", 1);
                result.put("msg", "文章不存在");
                return result;
            }
            article.setStatus(1); // 已发布
            articleService.updateById(article);
            result.put("code", 0);
            result.put("msg", "操作成功");
        } catch (Exception e) {
            result.put("code", 1);
            result.put("msg", "操作失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 拒绝某篇文章，将其状态设置为已驳回
     * @param id 文章ID
     * @return 操作结果
     */
    @PostMapping("/article/reject/{id}")
    @ResponseBody
    public Map<String, Object> rejectArticle(@PathVariable Integer id) {
        Map<String, Object> result = new HashMap<>();
        try {
            Article article = articleService.getById(id);
            if (article == null) {
                result.put("code", 1);
                result.put("msg", "文章不存在");
                return result;
            }
            article.setStatus(3); // 已驳回
            articleService.updateById(article);
            result.put("code", 0);
            result.put("msg", "操作成功");
        } catch (Exception e) {
            result.put("code", 1);
            result.put("msg", "操作失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 对文章执行批量操作：删除或审核通过
     * @param action 操作类型："delete" 或 "approve" 或 "reject"
     * @param ids    要操作的文章ID列表
     * @return 操作结果
     */
    @PostMapping("/article/batch")
    @ResponseBody
    public Map<String, Object> batchOperateArticles(@RequestParam String action,
                                                    @RequestParam List<Integer> ids) {
        Map<String, Object> result = new HashMap<>();
        try {
            if ("delete".equals(action)) {
                articleService.removeByIds(ids);
            } else if ("approve".equals(action)) {
                List<Article> articles = articleService.listByIds(ids);
                articles.forEach(article -> article.setStatus(1));
                articleService.updateBatchById(articles);
            } else if ("reject".equals(action)) {
                List<Article> articles = articleService.listByIds(ids);
                articles.forEach(article -> article.setStatus(3));
                articleService.updateBatchById(articles);
            }

            result.put("code", 0);
            result.put("msg", "操作成功");
        } catch (Exception e) {
            result.put("code", 1);
            result.put("msg", "操作失败：" + e.getMessage());
        }
        return result;
    }


    /**
     * 显示统计数据页面
     *
     * @param model 模型对象，用于传递数据到视图
     * @return 返回视图名称 "admin/stat"
     */
    @GetMapping("/stat")
    public String stats(Model model) {
        model.addAttribute("stat", getAdminStatistics());
        return "admin/stat";
    }

    /**
     * 分页展示评论列表，支持按内容搜索
     *
     * @param page    当前页码，默认为1
     * @param keyword 搜索关键词，可选
     * @param model   模型对象，用于传递数据到视图
     * @return 返回视图名称 "admin/comment_list"
     */
    @GetMapping("/comment/list")
    public String listComments(@RequestParam(defaultValue = "1") int page,
                            @RequestParam(required = false) String keyword,
                            Model model) {
        Page<Comment> commentPage = commentService.page(new Page<>(page, 10),
                new QueryWrapper<Comment>().like(keyword != null ? "content" : null, keyword));
        model.addAttribute("comments", commentPage.getRecords());
        model.addAttribute("page", commentPage);
        model.addAttribute("keyword", keyword);
        return "admin/comment_list";
    }

    /**
     * 删除指定ID的评论
     *
     * @param id 评论ID
     * @return 重定向到评论列表页面
     */
    @PostMapping("/comment/delete/{id}")
    public String deleteComment(@PathVariable Integer id) {
        commentService.removeById(id);
        return "redirect:/admin/comment/list";
    }

    /**
     * 更新用户的权限角色
     *
     * @param id   用户ID
     * @param role 新的角色标识
     * @return 重定向到用户列表页面
     */


    /**
     * 获取系统统计数据，包括用户数、文章数和评论数
     *
     * @return 包含统计数据的Map对象
     */
    @GetMapping("/stat/data")
    @ResponseBody
    public Map<String, Object> getStatData() {
        Map<String, Object> data = new HashMap<>();
        data.put("users", userService.count());
        data.put("articles", articleService.count());
        data.put("comments", commentService.count());
        // 确保使用 articleService 获取待审核文章数
        data.put("pending", articleService.count(new QueryWrapper<Article>().eq("status", 2)));
        data.put("total", userService.getAllPendingArticlesCount());
        return data;
    }

    /**
     * 记录管理员的操作日志
     *
     * @param action       操作描述
     * @param authentication Spring Security的认证对象
     * @return 返回操作结果提示字符串
     */
    @PostMapping("/log/action")
    public String logAdminAction(@RequestParam String action, Authentication authentication) {
        if (authentication != null && authentication.isAuthenticated()) {
            Object principal = authentication.getPrincipal();
            if (principal instanceof UserDetails userDetails) {
                String username = userDetails.getUsername();
                // 这里可以保存日志到数据库
                System.out.println("管理员操作日志 - 用户: " + username + ", 操作: " + action);
            }
        }
        return "操作已记录";
    }

    /**
     * 动态加载指定页面的内容（使用Thymeleaf模板引擎）
     *
     * @param page 页面标识符，如 "dashboard", "users" 等
     * @return 包含HTML内容的响应实体
     */
    @GetMapping("content/{page}")
    public ResponseEntity<Map<String, String>> loadContent(@PathVariable String page) {
        Map<String, String> response = new HashMap<>();
        
        try {
            String content = "";
            switch (page) {
                case "dashboard":
                    content = loadTemplateContent("admin/dashboard-content");
                    break;
                case "users":
                    content = loadTemplateContent("admin/user-list");
                    break;
                case "articles":
                    content = loadTemplateContent("admin/article-audit");
                    break;
                case "categories":
                    content = loadTemplateContent("admin/category-list");
                    break;
                case "stats":
                    content = loadTemplateContent("admin/stat");
                    break;
                default:
                    return ResponseEntity.status(404).body(Map.of("content", "<div class='alert alert-danger'>页面未找到</div>"));
            }
            
            response.put("content", content);
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            response.put("content", "<div class='alert alert-danger'>内容加载失败</div>");
            return ResponseEntity.status(500).body(response);
        }
    }

    /**
     * 加载指定的Thymeleaf模板内容
     *
     * @param templateName 模板名称
     * @return 处理后的HTML内容字符串
     */
    private String loadTemplateContent(String templateName) {
        Context context = new Context();
        return templateEngine.process(templateName, context);
    }

    /**
     * 获取管理员统计信息，包括用户数、文章数、评论数和待审文章数
     *
     * @return 包含统计信息的Map对象
     */
    private Map<String, Object> getAdminStatistics() {
        Map<String, Object> stat = new HashMap<>();
        stat.put("userCount", userService.count());
        stat.put("articleCount", articleService.count());
        stat.put("commentCount", commentService.count()); // 可扩展
        stat.put("auditCount", articleService.list(new QueryWrapper<Article>().eq("status", 2)).size());
        return stat;
    }

    /**
     * 获取所有用户数据（JSON 格式，用于 Layui 表格）
     *
     * @return 返回用户列表的 JSON 数据
     */
    @GetMapping("/user/data")
    @ResponseBody
    public List<User> listUserData() {
        return userService.list();
    }
}
